home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2010 April / PCWorld0410.iso / hity wydania / Bank smakow / AdobeAIRInstaller.exe / setup.swf / scripts / mx / collections / ArrayList.as < prev    next >
Text File  |  2009-11-20  |  10KB  |  328 lines
  1. package mx.collections
  2. {
  3.    import flash.events.EventDispatcher;
  4.    import flash.events.IEventDispatcher;
  5.    import flash.utils.IDataInput;
  6.    import flash.utils.IDataOutput;
  7.    import flash.utils.IExternalizable;
  8.    import flash.utils.getQualifiedClassName;
  9.    import mx.core.IPropertyChangeNotifier;
  10.    import mx.core.mx_internal;
  11.    import mx.events.CollectionEvent;
  12.    import mx.events.CollectionEventKind;
  13.    import mx.events.PropertyChangeEvent;
  14.    import mx.events.PropertyChangeEventKind;
  15.    import mx.resources.IResourceManager;
  16.    import mx.resources.ResourceManager;
  17.    import mx.utils.ArrayUtil;
  18.    import mx.utils.UIDUtil;
  19.    
  20.    use namespace mx_internal;
  21.    
  22.    public class ArrayList extends EventDispatcher implements IList, IExternalizable, IPropertyChangeNotifier
  23.    {
  24.       
  25.       mx_internal static const VERSION:String = "3.0.0.0";
  26.        
  27.       
  28.       private var _source:Array;
  29.       
  30.       private var _dispatchEvents:int = 0;
  31.       
  32.       private var _uid:String;
  33.       
  34.       private var resourceManager:IResourceManager;
  35.       
  36.       public function ArrayList(param1:Array = null)
  37.       {
  38.          resourceManager = ResourceManager.getInstance();
  39.          super();
  40.          disableEvents();
  41.          this.source = param1;
  42.          enableEvents();
  43.          _uid = UIDUtil.createUID();
  44.       }
  45.       
  46.       public function itemUpdated(param1:Object, param2:Object = null, param3:Object = null, param4:Object = null) : void
  47.       {
  48.          var _loc5_:PropertyChangeEvent;
  49.          (_loc5_ = new PropertyChangeEvent(PropertyChangeEvent.PROPERTY_CHANGE)).kind = PropertyChangeEventKind.UPDATE;
  50.          _loc5_.source = param1;
  51.          _loc5_.property = param2;
  52.          _loc5_.oldValue = param3;
  53.          _loc5_.newValue = param4;
  54.          itemUpdateHandler(_loc5_);
  55.       }
  56.       
  57.       public function readExternal(param1:IDataInput) : void
  58.       {
  59.          source = param1.readObject();
  60.       }
  61.       
  62.       private function internalDispatchEvent(param1:String, param2:Object = null, param3:int = -1) : void
  63.       {
  64.          var _loc4_:CollectionEvent = null;
  65.          var _loc5_:PropertyChangeEvent = null;
  66.          if(_dispatchEvents == 0)
  67.          {
  68.             if(hasEventListener(CollectionEvent.COLLECTION_CHANGE))
  69.             {
  70.                (_loc4_ = new CollectionEvent(CollectionEvent.COLLECTION_CHANGE)).kind = param1;
  71.                _loc4_.items.push(param2);
  72.                _loc4_.location = param3;
  73.                dispatchEvent(_loc4_);
  74.             }
  75.             if(hasEventListener(PropertyChangeEvent.PROPERTY_CHANGE) && (param1 == CollectionEventKind.ADD || param1 == CollectionEventKind.REMOVE))
  76.             {
  77.                (_loc5_ = new PropertyChangeEvent(PropertyChangeEvent.PROPERTY_CHANGE)).property = param3;
  78.                if(param1 == CollectionEventKind.ADD)
  79.                {
  80.                   _loc5_.newValue = param2;
  81.                }
  82.                else
  83.                {
  84.                   _loc5_.oldValue = param2;
  85.                }
  86.                dispatchEvent(_loc5_);
  87.             }
  88.          }
  89.       }
  90.       
  91.       public function removeAll() : void
  92.       {
  93.          var _loc1_:int = 0;
  94.          var _loc2_:int = 0;
  95.          if(length > 0)
  96.          {
  97.             _loc1_ = length;
  98.             _loc2_ = 0;
  99.             while(_loc2_ < _loc1_)
  100.             {
  101.                stopTrackUpdates(source[_loc2_]);
  102.                _loc2_++;
  103.             }
  104.             source.splice(0,length);
  105.             internalDispatchEvent(CollectionEventKind.RESET);
  106.          }
  107.       }
  108.       
  109.       public function removeItemAt(param1:int) : Object
  110.       {
  111.          var _loc3_:String = null;
  112.          if(param1 < 0 || param1 >= length)
  113.          {
  114.             _loc3_ = resourceManager.getString("collections","outOfBounds",[param1]);
  115.             throw new RangeError(_loc3_);
  116.          }
  117.          var _loc2_:Object = source.splice(param1,1)[0];
  118.          stopTrackUpdates(_loc2_);
  119.          internalDispatchEvent(CollectionEventKind.REMOVE,_loc2_,param1);
  120.          return _loc2_;
  121.       }
  122.       
  123.       public function get uid() : String
  124.       {
  125.          return _uid;
  126.       }
  127.       
  128.       public function getItemIndex(param1:Object) : int
  129.       {
  130.          return ArrayUtil.getItemIndex(param1,source);
  131.       }
  132.       
  133.       public function writeExternal(param1:IDataOutput) : void
  134.       {
  135.          param1.writeObject(_source);
  136.       }
  137.       
  138.       public function addItem(param1:Object) : void
  139.       {
  140.          addItemAt(param1,length);
  141.       }
  142.       
  143.       public function toArray() : Array
  144.       {
  145.          return source.concat();
  146.       }
  147.       
  148.       private function disableEvents() : void
  149.       {
  150.          --_dispatchEvents;
  151.       }
  152.       
  153.       public function get source() : Array
  154.       {
  155.          return _source;
  156.       }
  157.       
  158.       public function getItemAt(param1:int, param2:int = 0) : Object
  159.       {
  160.          var _loc3_:String = null;
  161.          if(param1 < 0 || param1 >= length)
  162.          {
  163.             _loc3_ = resourceManager.getString("collections","outOfBounds",[param1]);
  164.             throw new RangeError(_loc3_);
  165.          }
  166.          return source[param1];
  167.       }
  168.       
  169.       public function set uid(param1:String) : void
  170.       {
  171.          _uid = param1;
  172.       }
  173.       
  174.       public function setItemAt(param1:Object, param2:int) : Object
  175.       {
  176.          var _loc4_:String = null;
  177.          var _loc5_:Boolean = false;
  178.          var _loc6_:Boolean = false;
  179.          var _loc7_:PropertyChangeEvent = null;
  180.          var _loc8_:CollectionEvent = null;
  181.          if(param2 < 0 || param2 >= length)
  182.          {
  183.             _loc4_ = resourceManager.getString("collections","outOfBounds",[param2]);
  184.             throw new RangeError(_loc4_);
  185.          }
  186.          var _loc3_:Object = source[param2];
  187.          source[param2] = param1;
  188.          stopTrackUpdates(_loc3_);
  189.          startTrackUpdates(param1);
  190.          if(_dispatchEvents == 0)
  191.          {
  192.             _loc5_ = hasEventListener(CollectionEvent.COLLECTION_CHANGE);
  193.             _loc6_ = hasEventListener(PropertyChangeEvent.PROPERTY_CHANGE);
  194.             if(_loc5_ || _loc6_)
  195.             {
  196.                (_loc7_ = new PropertyChangeEvent(PropertyChangeEvent.PROPERTY_CHANGE)).kind = PropertyChangeEventKind.UPDATE;
  197.                _loc7_.oldValue = _loc3_;
  198.                _loc7_.newValue = param1;
  199.                _loc7_.property = param2;
  200.             }
  201.             if(_loc5_)
  202.             {
  203.                (_loc8_ = new CollectionEvent(CollectionEvent.COLLECTION_CHANGE)).kind = CollectionEventKind.REPLACE;
  204.                _loc8_.location = param2;
  205.                _loc8_.items.push(_loc7_);
  206.                dispatchEvent(_loc8_);
  207.             }
  208.             if(_loc6_)
  209.             {
  210.                dispatchEvent(_loc7_);
  211.             }
  212.          }
  213.          return _loc3_;
  214.       }
  215.       
  216.       public function get length() : int
  217.       {
  218.          if(source)
  219.          {
  220.             return source.length;
  221.          }
  222.          return 0;
  223.       }
  224.       
  225.       protected function stopTrackUpdates(param1:Object) : void
  226.       {
  227.          if(param1 && param1 is IEventDispatcher)
  228.          {
  229.             IEventDispatcher(param1).removeEventListener(PropertyChangeEvent.PROPERTY_CHANGE,itemUpdateHandler);
  230.          }
  231.       }
  232.       
  233.       protected function itemUpdateHandler(param1:PropertyChangeEvent) : void
  234.       {
  235.          var _loc2_:PropertyChangeEvent = null;
  236.          var _loc3_:uint = 0;
  237.          internalDispatchEvent(CollectionEventKind.UPDATE,param1);
  238.          if(_dispatchEvents == 0 && hasEventListener(PropertyChangeEvent.PROPERTY_CHANGE))
  239.          {
  240.             _loc2_ = PropertyChangeEvent(param1.clone());
  241.             _loc3_ = getItemIndex(param1.target);
  242.             _loc2_.property = _loc3_.toString() + "." + param1.property;
  243.             dispatchEvent(_loc2_);
  244.          }
  245.       }
  246.       
  247.       public function addItemAt(param1:Object, param2:int) : void
  248.       {
  249.          var _loc3_:String = null;
  250.          if(param2 < 0 || param2 > length)
  251.          {
  252.             _loc3_ = resourceManager.getString("collections","outOfBounds",[param2]);
  253.             throw new RangeError(_loc3_);
  254.          }
  255.          source.splice(param2,0,param1);
  256.          startTrackUpdates(param1);
  257.          internalDispatchEvent(CollectionEventKind.ADD,param1,param2);
  258.       }
  259.       
  260.       public function removeItem(param1:Object) : Boolean
  261.       {
  262.          var _loc2_:int = getItemIndex(param1);
  263.          var _loc3_:* = _loc2_ >= 0;
  264.          if(_loc3_)
  265.          {
  266.             removeItemAt(_loc2_);
  267.          }
  268.          return _loc3_;
  269.       }
  270.       
  271.       protected function startTrackUpdates(param1:Object) : void
  272.       {
  273.          if(param1 && param1 is IEventDispatcher)
  274.          {
  275.             IEventDispatcher(param1).addEventListener(PropertyChangeEvent.PROPERTY_CHANGE,itemUpdateHandler,false,0,true);
  276.          }
  277.       }
  278.       
  279.       override public function toString() : String
  280.       {
  281.          if(source)
  282.          {
  283.             return source.toString();
  284.          }
  285.          return getQualifiedClassName(this);
  286.       }
  287.       
  288.       private function enableEvents() : void
  289.       {
  290.          ++_dispatchEvents;
  291.          if(_dispatchEvents > 0)
  292.          {
  293.             _dispatchEvents = 0;
  294.          }
  295.       }
  296.       
  297.       public function set source(param1:Array) : void
  298.       {
  299.          var _loc2_:int = 0;
  300.          var _loc3_:int = 0;
  301.          var _loc4_:CollectionEvent = null;
  302.          if(_source && _source.length)
  303.          {
  304.             _loc3_ = _source.length;
  305.             _loc2_ = 0;
  306.             while(_loc2_ < _loc3_)
  307.             {
  308.                stopTrackUpdates(_source[_loc2_]);
  309.                _loc2_++;
  310.             }
  311.          }
  312.          _source = !!param1 ? param1 : [];
  313.          _loc3_ = _source.length;
  314.          _loc2_ = 0;
  315.          while(_loc2_ < _loc3_)
  316.          {
  317.             startTrackUpdates(_source[_loc2_]);
  318.             _loc2_++;
  319.          }
  320.          if(_dispatchEvents == 0)
  321.          {
  322.             (_loc4_ = new CollectionEvent(CollectionEvent.COLLECTION_CHANGE)).kind = CollectionEventKind.RESET;
  323.             dispatchEvent(_loc4_);
  324.          }
  325.       }
  326.    }
  327. }
  328.